package com.qf.stream;

import com.qf.function.pojo.Item;
import com.qf.function.pojo.Order;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/*
 *@Description:
 *@author:刘哥
 *@Date:86180 2022/9/2 16:25
 */
public class StreamTest {
    public static void main(String[] args) {
//        ArrayList<User> list = new ArrayList<>();
//        for (int i = 0; i < 10; i++) {
//            User user = new User();
//            user.setName("申志恒"+i+"号");
//            user.setAge(20+i);
//            user.setAddresss("沙河镇沙杨路");
//            list.add(user);
//        }
//        stream的核心思想:每次的原始数据不会被更改,修改的是副本
 /*
        List<User> collect = list.stream()//stream(内部迭代)
                .filter(user -> user.getAge() > 25)//过滤(里面放断言)
                .collect(Collectors.toList());//收集(收集到集合里面)
        System.out.println(collect.toString());
  */
//      map  转换:从一个数据类型变成另一个数据类型,利用我们内部迭代到的对象进行操作得到一个新的结果,然后返回
//        List<String> collect = list.stream()
////                .map(user -> user.getName())
//                .map(User::getName)//里面用的是Function函数()两个参数第一个形参,第二个是返回值类型
//                .collect(Collectors.toList());
//        System.out.println(collect);

//        ArrayList<String> strings = new ArrayList<>();
//        for (int i = 0; i < 20; i++) {
//            strings.add("不是好人"+i);
//        }
//        List<User> list1 = strings.stream()
//                .map(name -> {//转换
//                    User user = new User();
//                    user.setName(name);
//                    return user;
//                }).collect(Collectors.toList());//收集
//        System.out.println(list1);

//        List<User> collect = list.stream()
//                .peek(System.out::println)//遍历(可以在中间进行一次遍历)
////                .filter(System.out::println)//遍历(结束符,用了就不能做其他事)
//                .filter(user -> user.getAge() > 28)
//                .collect(Collectors.toList());
//        System.out.println(collect);
//        List<User> collect2 = list.stream()
//                .map(user -> {
//                    user.setName(user.getName()+"傻逼");
//                    return user;
//                })
////                .peek(user -> user.setName(user.getName()+"傻逼"))//遍历(可以在中间进行一次遍历)
////                .filter(System.out::println)//遍历(结束符,用了就不能做其他事)
//                .filter(user -> user.getAge() > 25)
//                .collect(Collectors.toList());
//        System.out.println(collect2);

//        boolean b = list.stream()
//                .allMatch(user -> user.getAge() < 18);//都满足为true
//        System.out.println("b = " + b);

//        boolean b1 = list.stream()
//                .anyMatch(user -> user.getAge() < 21);
//        System.out.println("b1 = " + b1);

//        boolean b2 = list.stream()
//                .noneMatch(user -> user.getAge() > 30); //都不满足为true
//        System.out.println("b2 = " + b2);

//        long count = list.stream()
//                .filter(user -> user.getAge() > 22)
//                .count();//统计
//        System.out.println("count = " + count);
//        User user1 = new User("申志恒2号",22,"沙河镇沙杨路");
//        list.add(user1);

//        List<User> collect = list.stream()
//                .distinct()//去重需要重写对象的equlas和hashcode方法
//                .peek(System.out::println)
//                .collect(Collectors.toList());
//        System.out.println("collect = " + collect);
//        Optional是一个值允许为空的容器,可以用来判断对象是否为空
//        Optional<User> any = list.stream()
//                .distinct()//去重需要重写对象的equlas和hashcode方法
//                .peek(System.out::println)
//                .findAny();//找到任意一个结果(结果较少是一般返回第一个与findfirst相似,但是比findfirst高效)
        ArrayList<Order> orderList= new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Order order=new Order();
            order.setId(i);
            ArrayList<Item> items = new ArrayList<>();
            for (int j = 0; j < 5; j++) {
                Item item = new Item();
                item.setName("鼠标"+i+"==========>"+j);
                item.setPrice(i*j+1);
                items.add(item);
            }
            order.setItems(items);
            orderList.add(order);
        }
//        List<Item> collect = orderList.stream()
////                如果有一个集合里面有一个集合数据,可以将集合里面的数据保存到另一个集合里面取出来
//                .flatMap(order -> order.getItems().stream())
//                .collect(Collectors.toList());
//        System.out.println(collect);

//        List<Order> count = orderList.stream()
////                跳过几条数据
//                .skip(2)
////                条2
//                .limit(2)
//                .collect(Collectors.toList());
////                .count();
//        System.out.println("count = " + count);
//        Order order = orderList.stream()
////                比较
//                .min((o1, o2) -> o1.getId() - o2.getId()).get();
//        Order order = orderList.stream().max((o1, o2) -> o1.getId() - o2.getId()).get();
//        System.out.println("order = " + order);
//返回的参数位的参数作为下一次输出的第一个参数
//        Order order = orderList.stream()
//                .reduce((order1, order2) -> {
//                    System.out.println("order = " + order1);
//                    System.out.println("order2 = " + order2);
//                    return order2;
//                }).get();
//        System.out.println("order = " + order);

//        orderList.stream()
////                排序,按自己定义的比较器
//                .sorted()

//        orderList.parallelStream()  //异步的stream操作(和正常的操作一样)
//                .sequential()//转回同步
    }
}